object CommonFunctions {
  def main(args: Array[String]): Unit = {
    /**
     * @ 7.7 集合常用函数
     * @ 7.7.1 基本属性和常用操作
     * 1）说明
     * （1）获取集合长度
     * （2）获取集合大小
     * （3）循环遍历
     * （4）迭代器
     * （5）生成字符串
     * （6）是否包含
     * */
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
    //（1）获取集合长度
    println(list.length)
    //（2）获取集合大小,等同于length
    println(list.size)
    //（3）循环遍历
    list.foreach(println)
    //（4）迭代器
    for (elem <- list.iterator) {
      println(elem)
    }
    //（5）生成字符串
    println(list.mkString(","))
    //（6）是否包含
    println(list.contains(3))

    /**
     * @ 7.7.2 衍生集合
     * 1）说明
     * （1）获取集合的头
     * （2）获取集合的尾（不是头的就是尾）
     * （3）集合最后一个数据
     * （4）集合初始数据（不包含最后一个）
     * （5）反转
     * （6）取前（后）n个元素
     * （7）去掉前（后）n个元素
     * （8）并集
     * （9）交集
     * （10）差集
     * （11）拉链
     * （12）滑窗
     * */
    println("=========================================")
    val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
    val list2: List[Int] = List(4, 5, 6, 7, 8, 9, 10)
    //（1）获取集合的头
    println(list1.head)
    //（2）获取集合的尾（不是头的就是尾）--除尾部以外所有元素
    println(list1.tail)
    //（3）集合最后一个数据
    println(list1.last)
    //（4）集合初始数据（不包含最后一个）--除头部以外所有元素
    println(list1.init)
    //（5）反转
    println(list1.reverse)
    //（6）取前（后）n个元素
    println(list1.take(3))
    println(list1.takeRight(3))
    //（7）去掉前（后）n个元素
    println(list1.drop(3))
    println(list1.dropRight(3))

    //（8）并集
    println(list1.union(list2))

    //（9）交集
    println(list1.intersect(list2))

    //（10）差集
    println(list1.diff(list2))

    //（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
    println(list1.zip(list2))

    //（12）滑窗 参数一：窗口大小 参数二：窗口滑动距离
    list1.sliding(2, 3).foreach(println)

    /**
     * @ 7.7.3 集合计算简单函数
     * （1）求和
     * （2）求乘积
     * （3）最大值
     * （4）最小值
     * （5）排序
     * */

    val list3: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
    //（1）求和
    println(list3.sum)
    //（2）求乘积
    println(list3.product)
    //（3）最大值
    println(list3.max)
    //（4）最小值
    println(list3.min)

    /**
     * （1）sorted
     * 对一个集合进行自然排序，通过传递隐式的Ordering
     * （2）sortBy
     * 对一个属性或多个属性进行排序，通过它的类型。
     * （3）sortWith
     * 基于函数的排序，通过一个comparator函数，实现自定义排序的逻辑。
     * */
    //（5）排序
    // （5.1）按照元素大小排序 -- 默认升序
    println(list3.sortBy(x => x))
    // （5.2）按照元素的绝对值大小排序
    println(list3.sortBy(x => x.abs))
    // （5.3）按元素大小升序排序
    println(list3.sortWith((x, y) => x < y))
    // （5.4）按元素大小降序排序
    println(list3.sortWith((x, y) => x > y))

    /**
     * 7.7.4 集合计算高级函数
     * 1）说明
     * （1）过滤
     * 遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
     * （2）转化/映射（map）
     * 将集合中的每一个元素映射到某一个函数
     * （3）扁平化
     * （4）扁平化+映射 注：flatMap相当于先进行map操作，在进行flatten操作
     * 集合中的每个元素的子元素映射到某个函数并返回新集合
     * （5）分组(group)
     * 按照指定的规则对集合的元素进行分组
     * （6）简化（归约）
     * （7）折叠
     * */
    val list10: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
    val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")

    //（1）过滤
    println(list10.filter(x => x % 2 == 0))

    //（2）转化/映射
    println(list10.map(x => x + 1))

    //（3）扁平化
    println(nestedList.flatten)

    //（4）扁平化+映射 注：flatMap相当于先进行map操作，在进行flatten 操作
    println(wordList.flatMap(x => x.split(" ")))

    //（5）分组 -- 结果是map型数据 key为分组依据，value为所分组
    println(list.groupBy(x => x % 3))
  }
}
